package com.example.show_auto.utils

import com.example.show_auto.data.Chef
import com.example.show_auto.data.Recipe

/**
 * 菜谱品级计算工具类
 * 根据厨师技法和菜谱技法需求计算菜谱品级
 */
object RecipeRankCalculator {
    
    /**
     * 计算菜谱品级
     * @param chef 厨师（包含技法加成后的数值）
     * @param recipe 菜谱
     * @return 品级：0=无法制作, 1=普通, 2=优级, 3=特级, 4=神级, 5=传级
     */
    fun calculateRecipeRank(chef: Chef, recipe: Recipe): Int {
        // 计算厨师在各个技法上相对于菜谱需求的倍数
        val skillRatios = mutableListOf<Double>()
        
        // 炒技法
        if (recipe.stirfry > 0) {
            skillRatios.add(chef.stirfry.toDouble() / recipe.stirfry)
        }
        
        // 煮技法
        if (recipe.boil > 0) {
            skillRatios.add(chef.boil.toDouble() / recipe.boil)
        }
        
        // 切技法
        if (recipe.knife > 0) {
            skillRatios.add(chef.knife.toDouble() / recipe.knife)
        }
        
        // 炸技法
        if (recipe.fry > 0) {
            skillRatios.add(chef.fry.toDouble() / recipe.fry)
        }
        
        // 烤技法
        if (recipe.bake > 0) {
            skillRatios.add(chef.bake.toDouble() / recipe.bake)
        }
        
        // 蒸技法
        if (recipe.steam > 0) {
            skillRatios.add(chef.steam.toDouble() / recipe.steam)
        }
        
        // 如果菜谱不需要任何技法，返回最高品级
        if (skillRatios.isEmpty()) {
            return 5
        }
        
        // 取最小的技法倍数作为品级判断依据
        val minRatio = skillRatios.minOrNull() ?: 0.0
        
        // 根据倍数确定品级
        // 1倍=可, 2倍=优级, 3倍=特级, 4倍=神级, 5倍=传级
        return when {
            minRatio < 1.0 -> 0  // 无法制作
            minRatio < 2.0 -> 1  // 可（1倍以上但不足2倍）
            minRatio < 3.0 -> 2  // 优级（2倍以上但不足3倍）
            minRatio < 4.0 -> 3  // 特级（3倍以上但不足4倍）
            minRatio < 5.0 -> 4  // 神级（4倍以上但不足5倍）
            else -> 5            // 传级（5倍及以上）
        }
    }
    
    /**
     * 获取品级显示文本
     * @param rank 品级数值
     * @return 品级文本
     */
    fun getRankText(rank: Int): String {
        return when (rank) {
            0 -> "无法制作"
            1 -> "可"
            2 -> "优级"
            3 -> "特级"
            4 -> "神级"
            5 -> "传级"
            else -> "未知"
        }
    }

    /**
     * 获取品级颜色（用于UI显示）
     * @param rank 品级数值
     * @return 颜色值（16进制）
     */
    fun getRankColor(rank: Int): Long {
        return when (rank) {
            0 -> 0xFF999999  // 灰色 - 无法制作
            1 -> 0xFF000000  // 黑色 - 可
            2 -> 0xFF4CAF50  // 绿色 - 优级
            3 -> 0xFFFF9800  // 橙色 - 特级
            4 -> 0xFFFF0000  // 红色 - 神级
            5 -> 0xFF9C27B0  // 紫色 - 传级
            else -> 0xFF000000  // 黑色 - 未知
        }
    }

    /**
     * 获取品级简化显示文本（用于小空间显示）
     * @param rank 品级数值
     * @return 简化文本
     */
    fun getRankShortText(rank: Int): String {
        return when (rank) {
            0 -> "×"
            1 -> "可"
            2 -> "优"
            3 -> "特"
            4 -> "神"
            5 -> "传"
            else -> "?"
        }
    }

    /**
     * 计算技法差值信息（当无法制作时）
     * @param chef 厨师（包含技法加成后的数值）
     * @param recipe 菜谱
     * @return 技法差值文本，如"炒-10 切-5"
     */
    fun getSkillDeficitText(chef: Chef, recipe: Recipe): String {
        val deficits = mutableListOf<String>()

        // 检查各个技法的差值
        if (recipe.stirfry > 0 && chef.stirfry < recipe.stirfry) {
            val deficit = recipe.stirfry - chef.stirfry
            deficits.add("炒-$deficit")
        }

        if (recipe.boil > 0 && chef.boil < recipe.boil) {
            val deficit = recipe.boil - chef.boil
            deficits.add("煮-$deficit")
        }

        if (recipe.knife > 0 && chef.knife < recipe.knife) {
            val deficit = recipe.knife - chef.knife
            deficits.add("切-$deficit")
        }

        if (recipe.fry > 0 && chef.fry < recipe.fry) {
            val deficit = recipe.fry - chef.fry
            deficits.add("炸-$deficit")
        }

        if (recipe.bake > 0 && chef.bake < recipe.bake) {
            val deficit = recipe.bake - chef.bake
            deficits.add("烤-$deficit")
        }

        if (recipe.steam > 0 && chef.steam < recipe.steam) {
            val deficit = recipe.steam - chef.steam
            deficits.add("蒸-$deficit")
        }

        return deficits.joinToString(" ")
    }
}
